home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / Buttons.C < prev    next >
C/C++ Source or Header  |  1990-12-20  |  9KB  |  417 lines
  1. //$Button,ButtonCommand,ActionButton,OnOffItem,ImageButton,RadioButton$
  2. //$ToggleButton,LabeledButton$
  3.  
  4. #include "Buttons.h"
  5. #include "Dialog.h"
  6. #include "WindowSystem.h"
  7.  
  8. //---- Button ------------------------------------------------------------------
  9.  
  10. AbstractMetaImpl0(Button);
  11.  
  12. Button::Button(int id, VObject *gop) : CompositeVObject(id, gop, 0)
  13. {
  14. }
  15.  
  16. Command *Button::DoLeftButtonDownCommand(Point, Token, int)
  17. {
  18.     return new ButtonCommand(this, contentRect, TestFlag(eButtonIdle));
  19. }
  20.  
  21. void Button::Flush(int msec)
  22. {
  23.     if (Enabled()) {
  24.     Highlight(On);
  25.     GraphicDelay(msec);
  26.     Highlight(Off);
  27.     DoOnItem(1, 0, gPoint0);
  28.     }
  29. }
  30.  
  31. void Button::DoOnItem(int m, VObject*, Point)
  32. {
  33.     if (m != 3)
  34.     Control(GetId(), cPartToggle, (void*) 1);
  35. }
  36.  
  37. //---- ButtonCommand -----------------------------------------------------------
  38.  
  39. ButtonCommand::ButtonCommand(Button* bf, Rectangle r, bool b)
  40. {
  41.     item= bf;
  42.     inside= TRUE;
  43.     lastinside= FALSE;
  44.     rect= r;
  45.     SetFlag(eCmdIdleEvents, b);
  46. }
  47.  
  48. void ButtonCommand::TrackFeedback(Point, Point, bool)
  49. {
  50.     if (inside != lastinside) {
  51.     item->Highlight(inside ? On : Off);
  52.     lastinside= inside;
  53.     }
  54. }
  55.  
  56. Command *ButtonCommand::TrackMouse(TrackPhase atp, Point, Point, Point np)
  57. {
  58.     inside= rect.ContainsPoint(np);
  59.     switch(atp) {
  60.     case eTrackPress:
  61.     if (TestFlag(eCmdIdleEvents))
  62.         item->DoOnItem(1, 0, np);
  63.     else
  64.         item->DoOnItem(3, 0, np);
  65.     break;        
  66.     case eTrackIdle:
  67.     if (lastinside && TestFlag(eCmdIdleEvents))
  68.         item->DoOnItem(2, 0, np);
  69.     break;
  70.     case eTrackExit:
  71.     case eTrackRelease:
  72.     if (lastinside) {
  73.         item->ForceRedraw();
  74.         if (! TestFlag(eCmdIdleEvents))
  75.         item->DoOnItem(0, 0, np);
  76.     }
  77.     return gNoChanges;
  78.     case eTrackMove:
  79.     break;
  80.     }
  81.     return this;
  82. }
  83.  
  84. //---- ImageButton -------------------------------------------------------------
  85.  
  86. MetaImpl(ImageButton, (TB(idleEvents), TP(bm1), TP(bm2), 0));
  87.  
  88. ImageButton::ImageButton(int id, Bitmap *b1, Bitmap *b2, bool idle) : Button(id)
  89. {
  90.     bm1= b1;
  91.     bm2= b2;
  92.     idleEvents= idle;
  93.     SetFlag(eVObjHFixed | eVObjVFixed);
  94. }
  95.  
  96. ImageButton::~ImageButton()
  97. {
  98. }
  99.  
  100. Metric ImageButton::GetMinSize()
  101. {
  102.     return Metric(Max(bm1->Size(), bm2->Size()));
  103. }
  104.  
  105. void ImageButton::DrawInner(Rectangle, bool highlight)
  106. {
  107.     GrPaintBitMap(contentRect, highlight ? bm2 : bm1,
  108.                    Enabled() ? ePatBlack : ePatGrey50);
  109. }
  110.  
  111. Command *ImageButton::DoLeftButtonDownCommand(Point , Token, int)
  112. {
  113.     return new ButtonCommand(this, contentRect, idleEvents);
  114. }
  115.  
  116. ostream& ImageButton::PrintOn(ostream &s)
  117. {
  118.     Button::PrintOn(s);
  119.     return s << idleEvents SP << bm1 SP << bm2 SP;
  120. }
  121.  
  122. istream& ImageButton::ReadFrom(istream &s)
  123. {
  124.     Button::ReadFrom(s);
  125.     return s >> Bool(idleEvents) >> bm1 >> bm2;
  126. }
  127.  
  128. //---- ActionButton ------------------------------------------------------------
  129.  
  130. MetaImpl0(ActionButton);
  131.  
  132. ActionButton::ActionButton(int id, VObject *g, bool dflt) : Button(id, g)
  133. {
  134.     SetFlag(eActionDefaultButton, dflt);
  135.     SetFlag(eVObjVFixed);
  136. }
  137.  
  138. ActionButton::ActionButton(int id, char *t, bool dflt) : Button(id, new TextItem(t))
  139. {
  140.     SetFlag(eActionDefaultButton, dflt);
  141.     SetFlag(eVObjVFixed);
  142. }
  143.  
  144. Metric ActionButton::GetMinSize()
  145. {
  146.     Metric m= Button::GetMinSize().Expand(Point(CalcBorder()));
  147.     m.extent.x= max(m.extent.x, (m.extent.y*3)/2);
  148.     return m;
  149. }
  150.  
  151. void ActionButton::SetOrigin(Point at)
  152. {
  153.     VObject *inner= At(0);
  154.  
  155.     VObject::SetOrigin(at);
  156.     at.y+= CalcBorder();
  157.     at.x+= (Width() - inner->Width())/2;
  158.     inner->SetOrigin(at);
  159. }
  160.  
  161. void ActionButton::SetExtent(Point e)
  162. {
  163.     VObject::SetExtent(e);
  164.     At(0)->CalcExtent();
  165. }
  166.  
  167. int ActionButton::Base()
  168. {
  169.     return At(0)->Base()+CalcBorder();
  170. }
  171.  
  172. void ActionButton::DrawHighlight(Rectangle)
  173. {
  174.     GrFillRoundRect(contentRect.Inset(CalcBorder()-gPoint2), 14);
  175. }
  176.  
  177. void ActionButton::Draw(Rectangle r)
  178. {
  179.     GrSetPenNormal();
  180.     if (! Enabled())
  181.     GrSetPenPattern(ePatGrey50);
  182.     GrStrokeRoundRect(contentRect.Inset(CalcBorder()-gPoint2), 14);
  183.  
  184.     if (TestFlag(eActionDefaultButton)) {
  185.     GrSetPenSize(2);
  186.     GrStrokeRoundRect(contentRect, 18);
  187.     }
  188.     Button::Draw(r);
  189. }
  190.  
  191. void ActionButton::Control(int id, int part, void *val)
  192. {
  193.     if (part == cPartToggle)
  194.     part= cPartAction;
  195.     Button::Control(id, part, val);
  196. }
  197.  
  198. void ActionButton::SetContainer(VObject *vop)
  199. {
  200.     Button::SetContainer(vop);
  201.     if (TestFlag(eActionDefaultButton)) {
  202.     DialogView *vp= (DialogView*) FindContainerOfClass(Meta(DialogView));
  203.     if (vp)
  204.         vp->SetDefaultButton(this);
  205.     }
  206. }
  207.  
  208. //---- OnOffItem ---------------------------------------------------------------
  209.  
  210. AbstractMetaImpl(OnOffItem, (TB(state), 0));
  211.  
  212. OnOffItem::OnOffItem(int id, Bitmap *b1, Bitmap *b2, Bitmap *b3, bool s) : Button(id)
  213. {
  214.     on= b1;
  215.     off= b2;
  216.     highlight= b3;
  217.     state= s;
  218. }
  219.  
  220. void OnOffItem::DoOnItem(int m, VObject*, Point)
  221. {
  222.     if (m != 3) {
  223.     SendDown(GetId(), cPartSetState, (void*) !state);
  224.     Control(GetId(), cPartToggle, (void*) state);
  225.     Changed();
  226.     }
  227. }
  228.  
  229. Metric OnOffItem::GetMinSize()
  230. {
  231.     return Metric(gPoint16, 14);
  232. }
  233.  
  234. int OnOffItem::Base()
  235. {
  236.     return (contentRect.extent.y/8)*7;
  237. }
  238.  
  239. void OnOffItem::Draw(Rectangle)
  240. {
  241.     GrPaintBitMap(contentRect, state ? on : off, Enabled() ? ePatBlack : ePatGrey50);
  242. }
  243.  
  244. void OnOffItem::SetState(bool s, bool redraw)
  245. {
  246.     if (s != state) {
  247.     state= s;
  248.     Changed();
  249.     if (redraw)
  250.         ForceRedraw();
  251.     }
  252. }
  253.  
  254. void OnOffItem::SendDown(int, int part, void *val)
  255. {   
  256.     switch (part) {
  257.     case cPartStateIsOn:
  258.     bool *b= (bool*)val;
  259.     if (state) 
  260.         *b= state;
  261.     break;
  262.     case cPartSetState:
  263.     SetState((bool) val);
  264.     break;
  265.     case cPartIncr:
  266.     SetState(TRUE);
  267.     break;
  268.     case cPartDecr:
  269.     SetState(FALSE);
  270.     break;
  271.     }
  272. }
  273.  
  274. ostream& OnOffItem::PrintOn(ostream &s)
  275. {
  276.     Button::PrintOn(s);
  277.     return s << state SP << on SP << off SP << highlight SP;
  278. }
  279.  
  280. istream& OnOffItem::ReadFrom(istream &s)
  281. {
  282.     Button::ReadFrom(s);
  283.     return s >> Bool(state) >> on >> off >> highlight;
  284. }
  285.  
  286. //---- RadioButton -------------------------------------------------------------
  287.  
  288. static u_short RadioButtonOnBits[]= {
  289. #   include "images/RadioButtonOn.image"
  290. };
  291.  
  292. static u_short RadioButtonOffBits[]= {
  293. #   include "images/RadioButtonOff.image"
  294. };
  295.  
  296. static u_short RadioButtonFeedbackBits[]= {
  297. #   include "images/RadioButtonFeedback.image"
  298. };
  299.  
  300. static Bitmap *radioButtonOn, *radioButtonOff, *radioButtonFeedback;
  301.  
  302. MetaImpl0(RadioButton);
  303.  
  304. RadioButton::RadioButton(int id, bool state)
  305.     : OnOffItem(id,
  306.         radioButtonOn ? radioButtonOn
  307.               : radioButtonOn= new Bitmap(16, RadioButtonOnBits),
  308.         radioButtonOff ? radioButtonOff
  309.               : radioButtonOff= new Bitmap(16, RadioButtonOffBits),
  310.         radioButtonFeedback ? radioButtonFeedback
  311.               : radioButtonFeedback= new Bitmap(16, RadioButtonFeedbackBits),
  312.         state)
  313. {
  314. }
  315.  
  316. void RadioButton::InitNew()
  317. {
  318.     on= radioButtonOn ? radioButtonOn
  319.               : radioButtonOn= new Bitmap(16, RadioButtonOnBits);
  320.     off= radioButtonOff ? radioButtonOff
  321.             : radioButtonOff= new Bitmap(16, RadioButtonOffBits);
  322.     highlight= radioButtonFeedback ? radioButtonFeedback
  323.         : radioButtonFeedback= new Bitmap(16, RadioButtonFeedbackBits);
  324. }
  325.  
  326. ostream& RadioButton::PrintOn(ostream &s)
  327. {
  328.     Button::PrintOn(s);
  329.     return s SP << state SP;
  330. }
  331.  
  332. istream& RadioButton::ReadFrom(istream &s)
  333. {
  334.     Button::ReadFrom(s);
  335.     return s >> Bool(state);
  336. }
  337.  
  338. //---- ToggleButton ------------------------------------------------------------
  339.  
  340. static u_short CheckMarkOnBits[]= {
  341. #   include "images/CheckmarkOn.image"
  342. };
  343.  
  344. static u_short CheckMarkOffBits[]= {
  345. #   include "images/CheckmarkOff.image"
  346. };
  347.  
  348. static u_short CheckMarkFeedbackBits[]= {
  349. #   include "images/CheckmarkInv.image"
  350. };
  351.  
  352. static Bitmap *CheckMarkOn, *CheckMarkOff, *CheckMarkFeedback;
  353.  
  354. MetaImpl0(ToggleButton);
  355.  
  356. ToggleButton::ToggleButton(int id, bool state)
  357.         : OnOffItem(id,
  358.             CheckMarkOn ? CheckMarkOn
  359.                 : CheckMarkOn= new Bitmap(16, CheckMarkOnBits),
  360.             CheckMarkOff ? CheckMarkOff
  361.                  : CheckMarkOff= new Bitmap(16, CheckMarkOffBits),
  362.             CheckMarkFeedback ? CheckMarkFeedback
  363.                       : CheckMarkFeedback= new Bitmap(16, CheckMarkFeedbackBits),
  364.             state)
  365. {
  366. }
  367.  
  368. void ToggleButton::InitNew()
  369. {
  370.     on= CheckMarkOn ? CheckMarkOn : CheckMarkOn= new Bitmap(16, CheckMarkOnBits);
  371.     off= CheckMarkOff ? CheckMarkOff : CheckMarkOff= new Bitmap(16, CheckMarkOffBits);
  372.     highlight= CheckMarkFeedback ? CheckMarkFeedback : CheckMarkFeedback= new Bitmap(16, CheckMarkFeedbackBits);
  373. }
  374.  
  375. ostream& ToggleButton::PrintOn(ostream &s)
  376. {
  377.     Button::PrintOn(s);
  378.     return s << state SP;
  379. }
  380.  
  381. istream& ToggleButton::ReadFrom(istream &s)
  382. {
  383.     Button::ReadFrom(s);
  384.     return s >> Bool(state);
  385. }
  386.  
  387. //---- LabeledButton -----------------------------------------------------------
  388.  
  389. MetaImpl0(LabeledButton);
  390.  
  391. LabeledButton::LabeledButton(int id, OnOffItem *b, VObject *g, Point gap,
  392.                     VObjAlign) : VObjectPair(b, g, gap)
  393. {
  394.     SetId(id);
  395. }
  396.  
  397. LabeledButton::LabeledButton(int id, char *t, bool w)
  398.            : VObjectPair(w ? (VObject*) new RadioButton
  399.                    : (VObject*) new ToggleButton,
  400.                  new TextItem(t),
  401.                  gPoint10)
  402. {
  403.     SetId(id);
  404. }
  405.  
  406. Command *LabeledButton::DoLeftButtonDownCommand(Point, Token, int)
  407. {
  408.     if (left->Enabled())
  409.     return new ButtonCommand((Button*)left, contentRect);
  410.     return gNoChanges;
  411. }
  412.  
  413. void LabeledButton::Control(int, int part, void *val)
  414. {
  415.     VObjectPair::Control(GetId(), part, val);
  416. }
  417.